home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / messages_lib.c < prev    next >
C/C++ Source or Header  |  1995-01-03  |  9KB  |  324 lines
  1. #include "wwbbs.h"
  2. #include "messages.h"
  3.  
  4. struct MessageNode *GetMessageNode(struct MessageGroupNode *gnode,ULONG id)
  5.     {
  6.         struct MessageNode *ret=NULL;
  7.         {
  8.             struct MessageNode *node;
  9.             for(node=(struct MessageNode *) gnode->mgn_Messages.lh_Head;node->mn_Node.ln_Succ;node=(struct MessageNode *) node->mn_Node.ln_Succ)
  10.                 {
  11.                     if(node->mn_ID==id)
  12.                         {
  13.                             ret=node;
  14.                             break;
  15.                         }
  16.                 }
  17.         }
  18.         return(ret);
  19.     }
  20.  
  21. ULONG GetMessageFields(struct MessageNode *node,struct TagItem *tags_orig)
  22.     {
  23.         ULONG ret=0;
  24.         struct TagItem *tags;
  25.         if(tags=CloneTagItems(tags_orig))
  26.             {
  27.                 if(FilterTagItems(tags,msg_tags,TAGFILTER_AND))
  28.                     {
  29.                         struct TagItem *tstate,*tag;
  30.                         APTR data;
  31.                         tstate=tags;
  32.                         while(tag=NextTagItem(&tstate))
  33.                             {
  34.                                 data=(APTR) tag->ti_Data;
  35.                                 switch(tag->ti_Tag)
  36.                                     {
  37.                                         case MSGTAG_Thread:
  38.                                             *((ULONG *) data)=node->mn_Thread;
  39.                                             break;
  40.                                         case MSGTAG_From:
  41.                                             *((STRPTR *) data)=node->mn_From;
  42.                                             break;
  43.                                         case MSGTAG_To:
  44.                                             *((STRPTR *) data)=node->mn_To;
  45.                                             break;
  46.                                         case MSGTAG_Subject:
  47.                                             *((STRPTR *) data)=node->mn_Subject;
  48.                                             break;
  49.                                         case MSGTAG_Date:
  50.                                             *((struct DateStamp **) data)=&node->mn_Date;
  51.                                             break;
  52.                                         case MSGTAG_Text:
  53.                                             *((STRPTR *) data)=node->mn_Text;
  54.                                             break;
  55.                                     }
  56.                                 ret++;
  57.                             }
  58.                     }
  59.                 FreeTagItems(tags);
  60.             }
  61.         return(ret);
  62.     }
  63.  
  64. ULONG SetMessageFields(struct MessageNode *node,struct TagItem *tags_orig)
  65.     {
  66.         ULONG ret=0,retminus=0;
  67.         struct TagItem *tags;
  68.         if(tags=CloneTagItems(tags_orig))
  69.             {
  70.                 if(FilterTagItems(tags,msg_tags,TAGFILTER_AND))
  71.                     {
  72.                         struct TagItem *tstate,*tag;
  73.                         APTR data;
  74.                         tstate=tags;
  75.                         while(tag=NextTagItem(&tstate))
  76.                             {
  77.                                 data=(APTR) tag->ti_Data;
  78.                                 switch(tag->ti_Tag)
  79.                                     {
  80.                                         case MSGTAG_Thread:
  81.                                             node->mn_Thread=(ULONG) data;
  82.                                             break;
  83.                                         case MSGTAG_From:
  84.                                             if(data && strlen((STRPTR) data)<=32)
  85.                                                 strcpy(node->mn_From,(STRPTR) data);
  86.                                             else
  87.                                                 retminus++;
  88.                                             break;
  89.                                         case MSGTAG_To:
  90.                                             if(data && strlen((STRPTR) data)<=32)
  91.                                                 strcpy(node->mn_To,(STRPTR) data);
  92.                                             else
  93.                                                 retminus++;
  94.                                             break;
  95.                                         case MSGTAG_Subject:
  96.                                             if(data && strlen((STRPTR) data)<=64)
  97.                                                 strcpy(node->mn_Subject,(STRPTR) data);
  98.                                             else
  99.                                                 retminus++;
  100.                                             break;
  101.                                         case MSGTAG_Date:
  102.                                             if(data)
  103.                                                 node->mn_Date=*((struct DateStamp *) data);
  104.                                             else
  105.                                                 retminus++;
  106.                                             break;
  107.                                         case MSGTAG_Text:
  108.                                             if(node->mn_Text)
  109.                                                 {
  110.                                                     FreeVec(node->mn_Text);
  111.                                                     node->mn_Text=NULL;
  112.                                                 }
  113.                                             if(data && (node->mn_Text=AllocVec(strlen((STRPTR) data)+1,MEMF_CLEAR)))
  114.                                                 strcpy(node->mn_Text,(STRPTR) data);
  115.                                             else
  116.                                                 retminus++;
  117.                                             break;
  118.                                     }
  119.                                 ret++;
  120.                             }
  121.                     }
  122.                 FreeTagItems(tags);
  123.             }
  124.         ret-=retminus;
  125.         return(ret);
  126.     }
  127.  
  128. BOOL LoadMessageGroup(BYTE *groupname)
  129.     {
  130.         BOOL ret=FALSE;
  131.         ObtainSemaphore(&MessageGroupSemaphore);
  132.         FlushMessageGroups();
  133.         {
  134.             struct MessageGroupNode *gnode;
  135.             if(gnode=AllocVec(sizeof(struct MessageGroupNode),MEMF_CLEAR))
  136.                 {
  137.                     InitSemaphore(&gnode->mgn_Semaphore);
  138.                     NewList(&gnode->mgn_Messages);
  139.                     InitSemaphore(&gnode->mgn_UsageCountSemaphore);
  140.                     strcpy(gnode->mgn_Name,groupname);
  141.                     gnode->mgn_Node.ln_Name=gnode->mgn_Name;
  142.                     {
  143.                         BYTE count_filename[256];
  144.                         BPTR count_fh;
  145.                         sprintf(count_filename,"WWBBS:Messages/%s.count",groupname);
  146.                         if(count_fh=Open(count_filename,MODE_OLDFILE))
  147.                             {
  148.                                 ULONG message_count,thread_count;
  149.                                 if(FRead(count_fh,&message_count,sizeof(ULONG),1) && FRead(count_fh,&thread_count,sizeof(ULONG),1))
  150.                                     {
  151.                                         gnode->mgn_MessageCount=message_count;
  152.                                         gnode->mgn_ThreadCount=thread_count;
  153.                                     }
  154.                                 Close(count_fh);
  155.                             }
  156.                     }
  157.                     {
  158.                         BYTE filename[256];
  159.                         BPTR fh;
  160.                         sprintf(filename,"WWBBS:Messages/%s.messages",groupname);
  161.                         if(fh=Open(filename,MODE_OLDFILE))
  162.                             {
  163.                                 BOOL kg=TRUE;
  164.                                 LONG cmd;
  165.                                 struct MessageNode *node=NULL;
  166.                                 while(kg)
  167.                                     {
  168.                                         cmd=FGetC(fh);
  169.                                         switch(cmd)
  170.                                             {
  171.                                                 case -1: /* EOF */
  172.                                                     kg=FALSE;
  173.                                                     break;
  174.                                                 case MSGCMD_Begin:
  175.                                                     if(!(node=AllocVec(sizeof(struct MessageNode),MEMF_CLEAR)))
  176.                                                         kg=FALSE;
  177.                                                     break;
  178.                                                 case MSGCMD_End:
  179.                                                     if(node)
  180.                                                         {
  181.                                                             AddTail(&gnode->mgn_Messages,(struct Node *) node);
  182.                                                             node=NULL;
  183.                                                         }
  184.                                                     break;
  185.                                                 case MSGCMD_Field:
  186.                                                     if(node)
  187.                                                         {
  188.                                                             LONG field;
  189.                                                             UWORD size;
  190.                                                             if( ((field=FGetC(fh))!=-1) && (FRead(fh,&size,sizeof(UWORD),1)) )
  191.                                                                 {
  192.                                                                     APTR data;
  193.                                                                     if(data=AllocVec(size,MEMF_CLEAR))
  194.                                                                         {
  195.                                                                             if(FRead(fh,data,size,1))
  196.                                                                                 {
  197.                                                                                     switch(field)
  198.                                                                                         {
  199.                                                                                             case MSGFLD_ID:
  200.                                                                                                 node->mn_ID=*((ULONG *) data);
  201.                                                                                                 break;
  202.                                                                                             case MSGFLD_Thread:
  203.                                                                                                 node->mn_Thread=*((ULONG *) data);
  204.                                                                                                 break;
  205.                                                                                             case MSGFLD_From:
  206.                                                                                                 strcpy(node->mn_From,(STRPTR) data);
  207.                                                                                                 break;
  208.                                                                                             case MSGFLD_To:
  209.                                                                                                 strcpy(node->mn_To,(STRPTR) data);
  210.                                                                                                 break;
  211.                                                                                             case MSGFLD_Subject:
  212.                                                                                                 strcpy(node->mn_Subject,(STRPTR) data);
  213.                                                                                                 break;
  214.                                                                                             case MSGFLD_Date:
  215.                                                                                                 node->mn_Date=*((struct DateStamp *) data);
  216.                                                                                                 break;
  217.                                                                                             case MSGFLD_Text:
  218.                                                                                                 if(node->mn_Text=AllocVec(size,MEMF_CLEAR))
  219.                                                                                                     strcpy(node->mn_Text,(STRPTR) data);
  220.                                                                                                 break;
  221.                                                                                         }
  222.                                                                                 }
  223.                                                                             else
  224.                                                                                 kg=FALSE;
  225.                                                                             FreeVec(data);
  226.                                                                         }
  227.                                                                     else
  228.                                                                         kg=FALSE;
  229.                                                                 }
  230.                                                             else
  231.                                                                 kg=FALSE;
  232.                                                         }
  233.                                                     break;
  234.                                             }
  235.                                     }
  236.                                 Close(fh);
  237.                             }
  238.                     }
  239.                     AddTail(&MessageGroupList,(struct Node *) gnode);
  240.                     ret=TRUE;
  241.                 }
  242.         }
  243.         ReleaseSemaphore(&MessageGroupSemaphore);
  244.         return(ret);
  245.     }
  246.  
  247. BOOL SaveMessageGroup(struct MessageGroupNode *gnode)
  248.     {
  249.         BOOL ret=FALSE;
  250.         {
  251.             BYTE filename[256];
  252.             BPTR fh;
  253.             sprintf(filename,"WWBBS:Messages/%s.messages",gnode->mgn_Name);
  254.             if(fh=Open(filename,MODE_NEWFILE))
  255.                 {
  256.                     struct MessageNode *node;
  257.                     for(node=(struct MessageNode *) gnode->mgn_Messages.lh_Head;node->mn_Node.ln_Succ;node=(struct MessageNode *) node->mn_Node.ln_Succ)
  258.                         {
  259.                             FPutC(fh,MSGCMD_Begin);
  260.                             SaveMessageField(fh,MSGFLD_ID,&node->mn_ID,sizeof(ULONG));
  261.                             SaveMessageField(fh,MSGFLD_Thread,&node->mn_Thread,sizeof(ULONG));
  262.                             SaveMessageString(fh,MSGFLD_From,node->mn_From);
  263.                             SaveMessageString(fh,MSGFLD_To,node->mn_To);
  264.                             SaveMessageString(fh,MSGFLD_Subject,node->mn_Subject);
  265.                             SaveMessageField(fh,MSGFLD_Date,&node->mn_Date,sizeof(struct DateStamp));
  266.                             if(node->mn_Text)
  267.                                 SaveMessageString(fh,MSGFLD_Text,node->mn_Text);
  268.                             FPutC(fh,MSGCMD_End);
  269.                         }
  270.                     {
  271.                         BYTE count_filename[256];
  272.                         BPTR count_fh;
  273.                         sprintf(count_filename,"WWBBS:Messages/%s.count",gnode->mgn_Name);
  274.                         if(count_fh=Open(count_filename,MODE_NEWFILE))
  275.                             {
  276.                                 FWrite(count_fh,&gnode->mgn_MessageCount,sizeof(ULONG),1);
  277.                                 FWrite(count_fh,&gnode->mgn_ThreadCount,sizeof(ULONG),1);
  278.                                 Close(count_fh);
  279.                                 ret=TRUE;
  280.                             }
  281.                     }
  282.                     Close(fh);
  283.                 }
  284.         }
  285.         return(ret);
  286.     }
  287.  
  288. void FlushMessageGroups()
  289.     {
  290.         struct MessageGroupNode *wn,*nn;
  291.         wn=(struct MessageGroupNode *) MessageGroupList.lh_Head;
  292.         while(nn=(struct MessageGroupNode *) wn->mgn_Node.ln_Succ)
  293.             {
  294.                 if(!wn->mgn_UsageCount)
  295.                     {
  296.                         {
  297.                             struct MessageNode *node;
  298.                             while(node=(struct MessageNode *) RemHead(&wn->mgn_Messages))
  299.                                 {
  300.                                     if(node->mn_Text)
  301.                                         FreeVec(node->mn_Text);
  302.                                     FreeVec(node);
  303.                                 }
  304.                         }
  305.                         Remove((struct Node *) wn);
  306.                         FreeVec(wn);
  307.                     }
  308.                 wn=nn;
  309.             }
  310.     }
  311.  
  312. void SaveMessageField(BPTR fh,LONG field,APTR data,UWORD size)
  313.     {
  314.         FPutC(fh,MSGCMD_Field);
  315.         FPutC(fh,field);
  316.         FWrite(fh,&size,sizeof(UWORD),1);
  317.         FWrite(fh,data,(ULONG) size,1);
  318.     }
  319.  
  320. void SaveMessageString(BPTR fh,LONG field,STRPTR data)
  321.     {
  322.         SaveMessageField(fh,field,data,strlen(data)+1);
  323.     }
  324.